Every class is a subtype of Object. If you want to have a List of everything, make it List<Object>. Primitive types are not objects, but when calling a method which requires an argument of type Object and doesn't provide an overload for the appropriate primitive, the primitive gets auto-boxed to its representative boxed type (e.g. int -> Integer) which then gets downcasted to Object such that it fits the type of the parameter.

List<Object> myEverythingBagel = new ArrayList<Object>();
myEverythingBagel.add(1);
myEverythingBagel.add("String");
// etc.

That is how you could do that, but the bigger question is why would you want to do that?

An everything-bagel collection can consume anything but will cause trouble when reading from it. Rather consider having dedicated collections for your different values.

Or better yet, when you have a relationship between those values, like name and age introduce a dedicated type for that entity. And for that take a look at Java records.

record Person(String name, int age)

Then you can store these people in a List<Person> people instead.

Tangent

Having a method parameter List<T> list is for when you want to pass differently typed Lists into the same method.

Keeping this method or it having generic parameters is not necessary when the initially created one is of type List<Object>. Because you just can call list.add(value) on it directly.

If you want to keep your "addDataToList" method (you could have planned it to do some logging or have other logic), you could change its signature to the following:

static <T> void addDataToList(Object t, List<Object> tList) {
    tList.add(t);
}

And your main method shouldn't be generic.

2nd Tangent

Forget that LinkedLists exists. They are only academically interesting when teaching data structures.

Most of the time you would want to use an ArrayList or if you want to represent a Stack/Queue take a look at ArrayDeque it implements the same Interface (Deque = Double-ended Queue) as LinkedList but performs much better.